﻿using IRUM.TR;
using IRUM.XingAPI;
using System;
using System.IO;
using System.Linq;
using System.Text;


namespace IRUM.Utils
{
	public class IRUM_Utils
	{
        public static TR_Type GetTR_Type(string szTrCode)
        {
            TR_Type code = TR_Type.S3_;

            while (szTrCode.CompareTo(code.ToString()) != 0)
            {
                code++;
            }

            return code;
        }

        //public static 종목구분 종목구분읽기(string 구분)
        //{
        //    종목구분 ret = 종목구분.Max;

        //    for (종목구분 i = 종목구분.전체; i < 종목구분.Max; i++)
        //    {
        //        if (i.ToString().Equals(구분))
        //        {
        //            ret = i;
        //        }
        //    }

        //    return ret;
        //}

        //public static 장상태 장상태읽기(string 상태)
        //{
        //    장상태 ret_val = 장상태.None;

        //    if (상태.Equals("11"))
        //    {
        //        ret_val = 장상태.장전동시호가개시;
        //    }
        //    else if (상태.Equals("21"))
        //    {
        //        ret_val = 장상태.장시작;
        //    }
        //    else if (상태.Equals("22"))
        //    {
        //        ret_val = 장상태.장개시10초전;
        //    }
        //    else if (상태.Equals("23"))
        //    {
        //        ret_val = 장상태.장개시1분전;
        //    }
        //    else if (상태.Equals("24"))
        //    {
        //        ret_val = 장상태.장개시5분전;
        //    }
        //    else if (상태.Equals("25"))
        //    {
        //        ret_val = 장상태.장개시10분전;
        //    }
        //    else if (상태.Equals("31"))
        //    {
        //        ret_val = 장상태.장후동시호가개시;
        //    }
        //    else if (상태.Equals("41"))
        //    {
        //        ret_val = 장상태.장마감;
        //    }
        //    else if (상태.Equals("42"))
        //    {
        //        ret_val = 장상태.장마감10초전;
        //    }
        //    else if (상태.Equals("43"))
        //    {
        //        ret_val = 장상태.장마감1분전;
        //    }
        //    else if (상태.Equals("44"))
        //    {
        //        ret_val = 장상태.장마감5분전;
        //    }
        //    else if (상태.Equals("51"))
        //    {
        //        ret_val = 장상태.시간외종가매매개시;
        //    }
        //    else if (상태.Equals("52"))
        //    {
        //        ret_val = 장상태.시간외종가매매종료;
        //    }
        //    else if (상태.Equals("53"))
        //    {
        //        ret_val = 장상태.시간외단일가매매개시;
        //    }
        //    else if (상태.Equals("54"))
        //    {
        //        ret_val = 장상태.시간외단일가매매종료;
        //    }
        //    else if (상태.Equals("61"))
        //    {
        //        ret_val = 장상태.서킷브레이크발동;
        //    }
        //    else if (상태.Equals("62"))
        //    {
        //        ret_val = 장상태.서킷브레이크해제;
        //    }
        //    else if (상태.Equals("63"))
        //    {
        //        ret_val = 장상태.서킷브레이크단일가접수;
        //    }

        //    return ret_val;
        //}

        //public static 매매구분 매매구분읽기(string 구분)
        //{
        //    매매구분 리턴 = 매매구분.None;

        //    if (구분 == null || 구분.Length == 0 || 구분.Equals(" "))
        //    {
        //        구분 = "0";
        //    }

        //    for (매매구분 i = 매매구분.None; i < 매매구분.Max; i++)
        //    {
        //        if (구분.Equals(Convert.ToInt32(i).ToString()))
        //        {
        //            리턴 = i;
        //            break;
        //        }
        //    }

        //    return 리턴;
        //}

        //public static 매매구분 체결구분읽기(string 구분)
        //{
        //    매매구분 리턴 = 매매구분.None;

        //    if (구분 != null)
        //    {
        //        if (구분.Equals("+"))
        //        {
        //            리턴 = 매매구분.매수;
        //        }
        //        else if (구분.Equals("-"))
        //        {
        //            리턴 = 매매구분.매도;
        //        }
        //    }

        //    return 리턴;
        //}

        //public static 차트상황 차트상황읽기(string 상황)
        //{
        //    차트상황 ret_val = 차트상황.None;

        //    for (차트상황 i = 차트상황.None; i < 차트상황.Max; i++)
        //    {
        //        if (i.ToString().Equals(상황))
        //        {
        //            ret_val = i;
        //        }
        //    }

        //    return ret_val;
        //}

        //public static 전일대비구분 전일대비구분읽기(string 구분)
        //{
        //    전일대비구분 ret_val = 전일대비구분.상한;

        //    for (전일대비구분 i = 전일대비구분.상한; i < 전일대비구분.하한; i++)
        //    {
        //        if (구분.Equals(Convert.ToInt32(i).ToString()))
        //        {
        //            ret_val = i;
        //            break;
        //        }
        //    }

        //    return ret_val;
        //}

        //public static DateTime 시간읽기(string time)
        //{
        //    int hour = Convert.ToInt32(time.Substring(0, 2));
        //    int minute = Convert.ToInt32(time.Substring(2, 2));
        //    int second = Convert.ToInt32(time.Substring(4, 2));

        //    return DateTime.Today.AddHours(hour).AddMinutes(minute).AddSeconds(second);
        //}

        //public static DateTime 시간읽기(string date, string time)
        //{
        //    int year = Convert.ToInt32(date.Substring(0, 4));
        //    int month = Convert.ToInt32(date.Substring(4, 2));
        //    int day = Convert.ToInt32(date.Substring(6, 2));
        //    int hour = 15;
        //    int minute = 0;
        //    int second = 0;

        //    if (time.Length > 0)
        //    {
        //        hour = Convert.ToInt32(time.Substring(0, 2));
        //        minute = Convert.ToInt32(time.Substring(2, 2));
        //        second = Convert.ToInt32(time.Substring(4, 2));
        //    }

        //    return new DateTime(year, month, day, hour, minute, second);
        //}

        //public static 종목분류 종목분류읽기(string 분류)
        //{
        //    종목분류 ret_val = 종목분류.None;

        //    for (종목분류 i = 종목분류.None; i < 종목분류.Max; i++)
        //    {
        //        if (분류.Equals(i.ToString()))
        //        {
        //            ret_val = i;
        //            break;
        //        }
        //    }

        //    return ret_val;
        //}

        //public static void 파일저장(string 경로, string 내용)
        //{
        //    FileStream fs;

        //    if (File.Exists(경로))
        //    {
        //        File.Delete(경로);
        //    }

        //    fs = new FileStream(경로, FileMode.Create);
        //    fs.Seek(0, SeekOrigin.Begin);

        //    byte[] info = Encoding.Default.GetBytes(내용);
        //    fs.Write(info, 0, info.Length);

        //    fs.Flush();
        //    fs.Close();
        //}

        //public static void 파일내용추가(string 경로, string 내용)
        //{
        //    FileStream fs;

        //    if (File.Exists(경로))
        //    {
        //        fs = new FileStream(경로, FileMode.Append);
        //        fs.Seek(0, SeekOrigin.End);
        //    }
        //    else
        //    {
        //        fs = new FileStream(경로, FileMode.Create);
        //        fs.Seek(0, SeekOrigin.Begin);
        //    }

        //    byte[] info = Encoding.Default.GetBytes(내용);
        //    fs.Write(info, 0, info.Length);

        //    fs.Flush();
        //    fs.Close();
        //}

        //public static void 파일내용삽입(string 경로, string 내용)
        //{
        //    string content = string.Empty;

        //    if (File.Exists(경로))
        //    {
        //        content = 파일읽기(경로);
        //        파일삭제(경로);
        //    }

        //    파일저장(경로, 내용 + content);
        //}

        //public static string 파일읽기(string 경로)
        //{
        //    string 결과 = string.Empty;

        //    if (File.Exists(경로))
        //    {
        //        FileStream fs = File.Open(경로, FileMode.Open);
        //        fs.Seek(0, SeekOrigin.Begin);
        //        int filesize = (int)fs.Length;

        //        byte[] buffer = new byte[filesize];
        //        fs.Read(buffer, 0, filesize);
        //        fs.Close();

        //        결과 = Encoding.Default.GetString(buffer);
        //    }

        //    return 결과;
        //}

        //public static void 파일삭제(string 경로)
        //{
        //    if (File.Exists(경로))
        //    {
        //        File.Delete(경로);
        //    }
        //}

        //public static bool 장중인가()
        //{
        //    bool result = false;
        //    DateTime now = DateTime.Now;

        //    if (now.DayOfWeek != DayOfWeek.Saturday && now.DayOfWeek != DayOfWeek.Sunday && now.Hour > 8 && (now.Hour < 14 || (now.Hour == 14 && now.Minute <= 59 && now.Second <= 59)))
        //    {
        //        result = true;
        //    }

        //    return result;
        //}

        //public static bool 동시호가전인가()
        //{
        //    bool result = false;
        //    DateTime now = DateTime.Now;

        //    if (now.DayOfWeek != DayOfWeek.Saturday && now.DayOfWeek != DayOfWeek.Sunday && now.Hour > 8 && (now.Hour < 14 || (now.Hour == 14 && now.Minute < 50)))
        //    {
        //        result = true;
        //    }

        //    return result;
        //}


        //public static DateTime 다음거래일구하기()
        //{
        //    const Int32 START_TIME = 7;
        //    const Int32 END_TIME = 15;

        //    bool 휴장 = true;
        //    DateTime 시작일시 = DateTime.Now;
        //    IRUM_DataClassesDataContext m_DC = new IRUM_DataClassesDataContext();

        //    while (휴장)
        //    {
        //        if (시작일시.DayOfWeek == DayOfWeek.Saturday)
        //        {
        //            시작일시 = 시작일시.AddDays(2);
        //        }
        //        else if (시작일시.DayOfWeek == DayOfWeek.Sunday)
        //        {
        //            시작일시 = 시작일시.AddDays(1);
        //        }
        //        else
        //        {
        //            if (m_DC.NoTradeDays.Count<NoTradeDays>(p => p.Date.Equals(시작일시.Date)) > 0)
        //            {
        //                시작일시 = 시작일시.AddDays(1);
        //            }
        //            else
        //            {
        //                if (시작일시.Hour < START_TIME)
        //                {
        //                    시작일시 = new DateTime(시작일시.Year, 시작일시.Month, 시작일시.Day, START_TIME, 0, 0);
        //                    휴장 = false;
        //                }
        //                else if (시작일시.Hour < END_TIME)
        //                {
        //                    if (시작일시.Day == DateTime.Today.Day)
        //                    {
        //                        시작일시 = DateTime.Now;
        //                    }
        //                    else
        //                    {
        //                        시작일시 = new DateTime(시작일시.Year, 시작일시.Month, 시작일시.Day, START_TIME, 0, 0);
        //                    }

        //                    휴장 = false;
        //                }
        //                else
        //                {
        //                    if (시작일시.Hour < START_TIME)
        //                    {
        //                        시작일시 = new DateTime(시작일시.Year, 시작일시.Month, 시작일시.Day, START_TIME, 0, 0);
        //                        휴장 = false;
        //                    }
        //                    else if (시작일시.Hour < END_TIME)
        //                    {
        //                        if (시작일시.Day == DateTime.Today.Day)
        //                        {
        //                            시작일시 = DateTime.Now;
        //                        }
        //                        else
        //                        {
        //                            시작일시 = new DateTime(시작일시.Year, 시작일시.Month, 시작일시.Day, START_TIME, 0, 0);
        //                        }

        //                        휴장 = false;
        //                    }
        //                    else
        //                    {
        //                        if (시작일시.Day == DateTime.Today.Day)
        //                        {
        //                            시작일시 = 시작일시.AddDays(1);
        //                        }
        //                        else
        //                        {
        //                            시작일시 = new DateTime(시작일시.Year, 시작일시.Month, 시작일시.Day, START_TIME, 0, 0);
        //                            휴장 = false;
        //                        }
        //                    }
        //                }
        //            }
        //        }
        //    }

        //    return 시작일시.Date;
        //}

        public static int WeekOfYear(DateTime time)
        {
            int result = 0;
            int start = (time.DayOfYear % 7 + 7 - Convert.ToInt32(time.DayOfWeek)) % 7;

            result = (time.DayOfYear + 7 - start) / 7 + 1;

            return result;
        }

        //public static DateTime 이달의마지막거래일(DateTime day)
        //{
        //    DateTime result = day.AddMonths(1).AddDays(day.Day * -1);
        //    IRUM_DataClassesDataContext m_DC = new IRUM_DataClassesDataContext();
        //    bool 휴장 = true;

        //    while (휴장 == true)
        //    {
        //        if (result.DayOfWeek == DayOfWeek.Sunday)
        //        {
        //            result = result.AddDays(-2);
        //        }
        //        else if (result.DayOfWeek == DayOfWeek.Saturday)
        //        {
        //            result = result.AddDays(-1);
        //        }
        //        else
        //        {
        //            if (m_DC.NoTradeDays.Count<NoTradeDays>(p => p.Date.Equals(result.Date)) > 0)
        //            {
        //                result = result.AddDays(-1);
        //            }
        //            else
        //            {
        //                휴장 = false;
        //            }
        //        }
        //    }

        //    return result;
        //}

        //public static DateTime 이주의마지막거래일(DateTime day)
        //{
        //    DateTime result = day;
        //    DateTime nextDay = 다음거래일구하기(result);

        //    IRUM_DataClassesDataContext m_DC = new IRUM_DataClassesDataContext();

        //    while (nextDay.DayOfWeek < DayOfWeek.Saturday)
        //    {
        //        if (m_DC.NoTradeDays.Count<NoTradeDays>(p => p.Date.Equals(nextDay.Date)) == 0)
        //        {
        //            result = nextDay;
        //        }

        //        nextDay = nextDay.AddDays(1);
        //    }

        //    return result;
        //}

        //public static DateTime 다음거래일구하기(DateTime 기준일)
        //{
        //    bool 휴장 = true;
        //    DateTime 시작일시 = 기준일.AddDays(1);
        //    IRUM_DataClassesDataContext m_DC = new IRUM_DataClassesDataContext();

        //    while (휴장)
        //    {
        //        if (시작일시.DayOfWeek == DayOfWeek.Saturday)
        //        {
        //            시작일시 = 시작일시.AddDays(2);
        //        }
        //        else if (시작일시.DayOfWeek == DayOfWeek.Sunday)
        //        {
        //            시작일시 = 시작일시.AddDays(1);
        //        }
        //        else
        //        {
        //            if (m_DC.NoTradeDays.Count<NoTradeDays>(p => p.Date.Equals(시작일시.Date)) > 0)
        //            {
        //                시작일시 = 시작일시.AddDays(1);
        //            }
        //            else
        //            {
        //                휴장 = false;
        //            }
        //        }
        //    }

        //    return 시작일시;
        //}

        public static DateTime GetLastTradingDateEvening(DateTime orig)
        {
            DateTime ret;

            if (orig.Hour < 17)
            {
                ret = orig.AddDays(-1);
            }
            else
            {
                ret = orig;
            }

            while (IsTradingDate(ret) == false)
            {
                ret = ret.AddDays(-1);
            }

            return ret;
        }

        private static DateTime GetClosingDateOfMonth(DateTime orig)
        {
            DateTime ret = new DateTime(orig.Year, orig.Month, 1);
            bool closingDate = false;

            while (closingDate == false)
            {
                if (ret.Day > 7 && ret.Day < 15 && ret.DayOfWeek == DayOfWeek.Thursday)
                {
                    closingDate = true;
                }
                else
                {
                    ret = ret.AddDays(1);
                }
            }

            return ret;
        }

        public static DateTime GetClosingDateOfOption(DateTime orig)
        {
            DateTime firstDay = new DateTime(orig.Year, orig.Month, 1);
            DateTime ret = GetClosingDateOfMonth(firstDay);

            if (orig > ret)
            {
                ret = GetClosingDateOfMonth(firstDay.AddMonths(1));
            }

            return ret;
        }

        public static DateTime GetClosingDateOfFuture(DateTime orig)
        {
            DateTime firstDay = new DateTime(orig.Year, orig.Month, 1);
            DateTime ret;

            int currMonth = firstDay.Month;
            if (currMonth % 3 == 0)
            {
                ret = GetClosingDateOfMonth(firstDay);

                if (orig > ret)
                {
                    ret = GetClosingDateOfMonth(firstDay.AddMonths(3));
                }
            }
            else
            {
                ret = GetClosingDateOfMonth(firstDay.AddMonths(3 - (currMonth % 3)));
            }

            return ret;
        }

        public static DateTime GetLastTradingDateForDay(DateTime orig)
        {
            bool isNonTradingDate = true;
            DateTime ret = orig;
            IRUMDataClassesDataContext dc = new IRUMDataClassesDataContext();

            while (isNonTradingDate)
            {
                if (ret.DayOfWeek == DayOfWeek.Saturday)
                {
                    ret = ret.AddDays(-1);
                }
                else if (ret.DayOfWeek == DayOfWeek.Sunday)
                {
                    ret = ret.AddDays(-2);
                }
                else
                {
                    if (dc.NoTradingDates.Count<NoTradingDate>(p => p.date.Equals(ret.Date)) > 0)
                    {
                        ret = ret.AddDays(-1);
                    }
                    else
                    {
                        if (ret.Hour > 14)
                        {
                            isNonTradingDate = false;
                        }
                        else
                        {
                            ret = ret.AddDays(-1).Date.AddHours(15);
                        }
                    }
                }
            }

            return ret.Date;
        }

        public static bool IsTradingDate(DateTime date)
        {
            bool result = true;
            IRUMDataClassesDataContext dc = new IRUMDataClassesDataContext();

            if (date.DayOfWeek == DayOfWeek.Saturday)
            {
                result = false;
            }
            else if (date.DayOfWeek == DayOfWeek.Sunday)
            {
                result = false;
            }
            else if (dc.NoTradingDates.Count<NoTradingDate>(p => p.date.Equals(date.Date)) > 0)
            {
                result = false;
            }

            return result;
        }

        public static DateTime ConvertStringToDateTime(string strDate)
        {
            int year = Convert.ToInt32(strDate.Substring(0, 4));
            int month = Convert.ToInt32(strDate.Substring(4, 2));
            int day = Convert.ToInt32(strDate.Substring(6, 2));

            return new DateTime(year, month, day);
        }

        public static float FindOriginPrice(double close)
        {
            int div = Convert.ToInt32(Math.Truncate(close / 2.5));
            float downPrice = div * 2.5f;
            float upPrice = (div + 1) * 2.5f;

            if (upPrice - close > close - downPrice)
            {
                return downPrice;
            }
            else
            {
                return upPrice;
            }
        }

        public static float GetExercisePriceFromShcode(string shcode)
        {
            string strPrice = shcode.Substring(shcode.Length - 3);
            int intPrice = Convert.ToInt32(strPrice);
            float price = intPrice;

            if (intPrice % 5 == 2)
            {
                price += 0.5f;
            }

            return price;
        }
	}
}
